home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 23 / AACD 23.iso / AACD / Programming / Wipeout / source / addresstest.c next >
C/C++ Source or Header  |  2000-12-21  |  3KB  |  148 lines
  1. /*
  2.  * $Id: addresstest.c 1.6 1998/04/13 09:39:45 olsen Exp olsen $
  3.  *
  4.  * :ts=4
  5.  *
  6.  * Wipeout -- Traces and munges memory and detects memory trashing
  7.  *
  8.  * Written by Olaf `Olsen' Barthel <olsen@sourcery.han.de>
  9.  * Public Domain
  10.  */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "global.h"
  14. #endif    /* _GLOBAL_H */
  15.  
  16. /******************************************************************************/
  17.  
  18. #define NOT_IN_RAM (0)
  19.  
  20. /******************************************************************************/
  21.  
  22. #define ROM_SIZE_OFFSET 0x13
  23.  
  24. /******************************************************************************/
  25.  
  26. BOOL
  27. IsValidAddress(ULONG address)
  28. {
  29.     BOOL isValid = FALSE;
  30.  
  31.     /* Is this a valid RAM address? */
  32.     if(TypeOfMem((APTR)address) == NOT_IN_RAM)
  33.     {
  34.         extern LONG FAR romend;
  35.  
  36.         const ULONG romEnd        = (ULONG)&romend;
  37.         const ULONG romStart    = romEnd - (*(ULONG *)(romEnd - ROM_SIZE_OFFSET));
  38.  
  39.         /* Check if the address resides in ROM space. */
  40.         if(romStart <= address && address <= romEnd)
  41.             isValid = TRUE;
  42.     }
  43.     else
  44.     {
  45.         isValid = TRUE;
  46.     }
  47.  
  48.     /* In this context "valid" means that the data stored
  49.      * at the given address is safe to read.
  50.      */
  51.     return(isValid);
  52. }
  53.  
  54. /******************************************************************************/
  55.  
  56. BOOL
  57. IsInvalidAddress(ULONG address)
  58. {
  59.     BOOL isInvalid;
  60.  
  61.     isInvalid = (BOOL)(TypeOfMem((APTR)address) == NOT_IN_RAM);
  62.  
  63.     /* In this context "invalid" means that the data stored
  64.      * at the given address is not located in RAM, but
  65.      * somewhere else.
  66.      */
  67.     return(isInvalid);
  68. }
  69.  
  70. BOOL
  71. IsOddAddress(ULONG address)
  72. {
  73.     BOOL isOdd;
  74.  
  75.     isOdd = (BOOL)((address & 3) != 0);
  76.  
  77.     return(isOdd);
  78. }
  79.  
  80. /******************************************************************************/
  81.  
  82. BOOL
  83. IsAllocatedMemory(ULONG address,ULONG size)
  84. {
  85.     struct MemHeader * mh;
  86.     struct MemChunk * mc;
  87.     ULONG memStart;
  88.     ULONG memStop;
  89.     ULONG chunkStart;
  90.     ULONG chunkStop;
  91.     BOOL isAllocated = TRUE;
  92.  
  93.     /* check whether the allocated memory overlaps with free
  94.      * memory or whether freeing it would result in part of
  95.      * an already free area to be freed
  96.      */
  97.  
  98.     memStart    = address;
  99.     memStop        = address + size-1;
  100.  
  101.     Forbid();
  102.  
  103.     for(mh = (struct MemHeader *)SysBase->MemList.lh_Head ;
  104.         mh->mh_Node.ln_Succ != NULL ;
  105.         mh = (struct MemHeader *)mh->mh_Node.ln_Succ)
  106.     {
  107.         for(mc = mh->mh_First ;
  108.             mc != NULL ;
  109.             mc = mc->mc_Next)
  110.         {
  111.             chunkStart    = (ULONG)mc;
  112.             chunkStop    = chunkStart + mc->mc_Bytes-1;
  113.  
  114.             /* four cases are possible:
  115.              * 1) the chunk and the allocated memory do not overlap
  116.              * 2) the chunk and the allocated memory overlap at the beginning
  117.              * 3) the chunk and the allocated memory overlap at the end
  118.              * 4) the chunk and the allocated memory overlap completely
  119.              */
  120.  
  121.             if(memStop < chunkStart || memStart > chunkStop)
  122.             {
  123.                 /* harmless */
  124.             }
  125.             else if (memStart <= chunkStart && memStop <= chunkStop)
  126.             {
  127.                 isAllocated = FALSE;
  128.                 break;
  129.             }
  130.             else if (chunkStart <= memStart && chunkStop <= memStop)
  131.             {
  132.                 isAllocated = FALSE;
  133.                 break;
  134.             }
  135.             else if (  memStart <= chunkStart && chunkStop <= memStop ||
  136.                      chunkStart <= memStart   &&   memStop <= chunkStop)
  137.             {
  138.                 isAllocated = FALSE;
  139.                 break;
  140.             }
  141.         }
  142.     }
  143.  
  144.     Permit();
  145.  
  146.     return(isAllocated);
  147. }
  148.